package com.ruoyi.demo;

import cn.hutool.core.lang.Console;
import cn.hutool.core.lang.Filter;
import cn.hutool.core.lang.tree.Tree;
import cn.hutool.core.lang.tree.TreeNode;
import cn.hutool.core.lang.tree.TreeNodeConfig;
import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.common.core.domain.entity.SysMenu;
import com.ruoyi.common.utils.TreeBuildUtils;
import com.ruoyi.demo.domain.TestTree;
import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

/**
 * <简述>
 * <详细描述>
 *
 * @author syf
 * @date 2024年08月15日 15:47
 */
@Slf4j
public class TestTreeNode {
   static List<TreeNode<Integer>> createTreeNodes(){
       List<TreeNode<Integer>> list = new ArrayList<>();
       TreeNode<Integer>  root= new TreeNode<>();
       root.setName("总公司");
       root.setId(1);
       root.setParentId(0);

       TreeNode<Integer>  node1= new TreeNode<>();
       node1.setName("分子公司1");node1.setId(2);node1.setParentId(1);


       TreeNode<Integer>  node2= new TreeNode<>();
       node2.setName("财务部");node2.setId(3);node2.setParentId(2);
       TreeNode<Integer>  node3= new TreeNode<>();
       node3.setName("开发部").setId(4).setParentId(2);

       list.add(root);
       list.add(node1);
       list.add(node2);
       list.add(node3);
       return list;
   }

    public static void main(String[] args) {
        buildSingle();
    }

    static void  buildSingle(){
        List<TreeNode<Integer>> list = createTreeNodes();

        //build 对比上面 去掉最外层 null 的父节点
        List<Tree<Integer>> build = TreeBuildUtils.build(list);
        Console.log(build);


        Console.log("-------------------------------------------测试开始------------------------------------------------");

        //原生 构建树结构
        Tree<Integer> integerTree = TreeBuildUtils.buildSingle(list);
        Console.log(integerTree);

        // 获取父节点
        Tree<Integer> parent = integerTree.getParent();
        Console.log("getParent->{}", parent);
        // 获取节点
        Tree<Integer> node = integerTree.getNode(2);
        Console.log("getNode->{}", node);
        // 获取父节点名称
        List<CharSequence> parentsName = integerTree.getParentsName(4, true);
        Console.log("getParentsName->{}", parentsName);
        // 获取配置
        TreeNodeConfig config = integerTree.getConfig();


        // 添加子节点
//        Tree<Integer> integerTree1 = integerTree.addChildren(node);
//        Console.log("addChildren->{}", integerTree1);
        // 判断是否有子节点
        boolean b = integerTree.hasChild();
        Console.log("hasChild->{}", b);
        // 获取子节点
        List<Tree<Integer>> children = integerTree.getChildren();
        Console.log("getChildren->{}", children);

        //遍历整数树结构，并打印每个节点
        integerTree.walk(new Consumer<Tree<Integer>>() {
            @Override
            public void accept(Tree<Integer> integerTree) {
                // 打印节点
                Console.log("walk->{}", integerTree);
            }
        });


        //根据是否包含特定名称（如“分子公司”）来筛选树结构数据
        Tree<Integer> filterNew = integerTree.filterNew(new Filter<Tree<Integer>>() {
            @Override
            public boolean accept(Tree<Integer> integerTree) {
                if (null != integerTree.getName() && integerTree.getName().toString().contains("分子公司")) {
                    return true;
                }
                return false;
            }
        });
        Console.log("filterNew->{}", filterNew);


        // 创建一个过滤器，用于筛选出名称中包含"分子公司"的Tree对象
        Tree<Integer> filter = filterNew.filter(new Filter<Tree<Integer>>() {
            @Override
            public boolean accept(Tree<Integer> integerTree) {
                if (null != integerTree.getName() && integerTree.getName().toString().contains("分子公司")) {
                    return true;
                }
                return false;
            }
        });
        Console.log("filter->{}", filter);


        // 克隆一个整数树结构
        Tree<Integer> integerTree2 = integerTree.cloneTree();
        Console.log("cloneTree->{}", integerTree2);


    }


}
